<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
        <head>
          <title>akka.util.ByteString.ByteString1</title>
          <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
          
      <link type="text/css" media="screen" rel="stylesheet" href="../../lib/template.css" />
      <script type="text/javascript" src="../../lib/jquery.js"></script>
      <script type="text/javascript" src="../../lib/jquery-ui.js"></script>
      <script type="text/javascript" src="../../lib/template.js"></script>
      <script type="text/javascript" src="../../lib/tools.tooltip.js"></script>
    
        </head>
        <body class="type">
      <div id="definition">
        <img src="../../lib/class_big.png" />
        <p id="owner"><a name="akka" class="extype" href="../package.html">akka</a>.<a name="akka.util" class="extype" href="package.html">util</a>.<a name="akka.util.ByteString" class="extype" href="ByteString$.html">ByteString</a></p>
        <h1>ByteString1</h1>
      </div>

      <h4 class="signature" id="signature">
      <span class="kind">class</span>
      <span class="symbol">
        <span class="name">ByteString1</span>
        
        <span class="result"> extends <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      
          <div class="fullcommenttop" id="comment"><div class="comment cmt"><p>An unfragmented ByteString.
</p></div><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd></dl><div class="toggleContainer block">
          <span class="toggle">Linear Supertypes</span>
          <div class="superTypes hiddenContent"><a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, <span name="scala.collection.IndexedSeqOptimized" class="extype">IndexedSeqOptimized</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.IndexedSeq" class="extype">IndexedSeq</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.IndexedSeqLike" class="extype">IndexedSeqLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], <span name="scala.collection.immutable.Seq" class="extype">Seq</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.Seq" class="extype">Seq</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.SeqLike" class="extype">SeqLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.GenSeqLike" class="extype">GenSeqLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Int" class="extype">Int</span>, <span name="scala.Byte" class="extype">Byte</span>], (<span name="scala.Int" class="extype">Int</span>) ⇒ <span name="scala.Byte" class="extype">Byte</span>, <span name="scala.collection.immutable.Iterable" class="extype">Iterable</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.Iterable" class="extype">Iterable</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.IterableLike" class="extype">IterableLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], <span name="scala.Equals" class="extype">Equals</span>, <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.GenIterableLike" class="extype">GenIterableLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], <span name="scala.collection.immutable.Traversable" class="extype">Traversable</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.Immutable" class="extype">Immutable</span>, <span name="scala.collection.Traversable" class="extype">Traversable</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.GenTraversable" class="extype">GenTraversable</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.generic.GenericTraversableTemplate" class="extype">GenericTraversableTemplate</span>[<span name="scala.Byte" class="extype">Byte</span>, <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>], <span name="scala.collection.TraversableLike" class="extype">TraversableLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], <span name="scala.collection.GenTraversableLike" class="extype">GenTraversableLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], <span name="scala.collection.Parallelizable" class="extype">Parallelizable</span>[<span name="scala.Byte" class="extype">Byte</span>, <span name="scala.collection.parallel.immutable.ParSeq" class="extype">ParSeq</span>[<span name="scala.Byte" class="extype">Byte</span>]], <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[<span name="scala.Byte" class="extype">Byte</span>], <span name="scala.collection.generic.FilterMonadic" class="extype">FilterMonadic</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], <span name="scala.collection.generic.HasNewBuilder" class="extype">HasNewBuilder</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>], AnyRef, <span name="scala.Any" class="extype">Any</span></div>
        </div></div>
        

      <div id="template">

        <div id="mbrsel">
          <div id="textfilter"><span class="pre"></span><span class="input"><input accesskey="/" type="text" /></span><span class="post"></span></div>
          <div id="order">
                <span class="filtertype">Ordering</span>
                <ol><li class="alpha in"><span>Alphabetic</span></li><li class="inherit out"><span>By inheritance</span></li></ol>
              </div>
          <div id="ancestors">
                <span class="filtertype">Inherited</span>
                <ol><li class="hideall out"><span>Hide All</span></li>
                <li class="showall in"><span>Show all</span></li></ol>
                <ol id="linearization"><li name="akka.util.ByteString.ByteString1" class="in"><span>ByteString1</span></li><li name="akka.util.ByteString" class="in"><span>ByteString</span></li><li name="scala.collection.IndexedSeqOptimized" class="in"><span>IndexedSeqOptimized</span></li><li name="scala.collection.immutable.IndexedSeq" class="in"><span>IndexedSeq</span></li><li name="scala.collection.IndexedSeq" class="in"><span>IndexedSeq</span></li><li name="scala.collection.IndexedSeqLike" class="in"><span>IndexedSeqLike</span></li><li name="scala.collection.immutable.Seq" class="in"><span>Seq</span></li><li name="scala.collection.Seq" class="in"><span>Seq</span></li><li name="scala.collection.SeqLike" class="in"><span>SeqLike</span></li><li name="scala.collection.GenSeq" class="in"><span>GenSeq</span></li><li name="scala.collection.GenSeqLike" class="in"><span>GenSeqLike</span></li><li name="scala.PartialFunction" class="in"><span>PartialFunction</span></li><li name="scala.Function1" class="in"><span>Function1</span></li><li name="scala.collection.immutable.Iterable" class="in"><span>Iterable</span></li><li name="scala.collection.Iterable" class="in"><span>Iterable</span></li><li name="scala.collection.IterableLike" class="in"><span>IterableLike</span></li><li name="scala.Equals" class="in"><span>Equals</span></li><li name="scala.collection.GenIterable" class="in"><span>GenIterable</span></li><li name="scala.collection.GenIterableLike" class="in"><span>GenIterableLike</span></li><li name="scala.collection.immutable.Traversable" class="in"><span>Traversable</span></li><li name="scala.Immutable" class="in"><span>Immutable</span></li><li name="scala.collection.Traversable" class="in"><span>Traversable</span></li><li name="scala.collection.GenTraversable" class="in"><span>GenTraversable</span></li><li name="scala.collection.generic.GenericTraversableTemplate" class="in"><span>GenericTraversableTemplate</span></li><li name="scala.collection.TraversableLike" class="in"><span>TraversableLike</span></li><li name="scala.collection.GenTraversableLike" class="in"><span>GenTraversableLike</span></li><li name="scala.collection.Parallelizable" class="in"><span>Parallelizable</span></li><li name="scala.collection.TraversableOnce" class="in"><span>TraversableOnce</span></li><li name="scala.collection.GenTraversableOnce" class="in"><span>GenTraversableOnce</span></li><li name="scala.collection.generic.FilterMonadic" class="in"><span>FilterMonadic</span></li><li name="scala.collection.generic.HasNewBuilder" class="in"><span>HasNewBuilder</span></li><li name="scala.AnyRef" class="in"><span>AnyRef</span></li><li name="scala.Any" class="in"><span>Any</span></li></ol>
              </div>
          <div id="visbl">
              <span class="filtertype">Visibility</span>
              <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
            </div>
        </div>

        

        <div class="types members" id="types">
              <h3>Type Members</h3>
              <ol><li visbl="prt" name="scala.collection.TraversableLike#Self" data-isabs="false">
      <a id="Self:Self"></a>
      <h4 class="signature">
      <span class="kind">type</span>
      <span class="symbol">
        <span class="name">Self</span>
        
        <span class="result"> = <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li></ol>
            </div>

        

        <div class="values members" id="values">
              <h3>Value Members</h3>
              <ol><li visbl="pub" name="scala.AnyRef#!=" data-isabs="false">
      <a id="!=(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">!=</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#!=" data-isabs="false">
      <a id="!=(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">!=</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef###" data-isabs="false">
      <a id="##():Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">##</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#++" data-isabs="false">
      <a id="++(ByteString):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">++</span>
        
        <span class="params">(<span name="that">that: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Efficiently concatenate another ByteString.</p><div class="fullcomment"><div class="comment cmt"><p>Efficiently concatenate another ByteString.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++" data-isabs="false">
      <a id="++[B&gt;:Byte, That](TraversableOnce[B])(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">++</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++" data-isabs="false">
      <a id="++[B&gt;:Byte, That](GenTraversableOnce[B])(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">++</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++:" data-isabs="false">
      <a id="++:[B&gt;:Byte, That](Traversable[B])(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">++:</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Traversable" class="extype">Traversable</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++:" data-isabs="false">
      <a id="++:[B&gt;:Byte, That](TraversableOnce[B])(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">++:</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#+:" data-isabs="false">
      <a id="+:[B&gt;:Byte, That](B)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">+:</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="elem">elem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#/:" data-isabs="false">
      <a id="/:[B](B)((B, Byte) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">/:</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, <span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenTraversableOnce#/:\" data-isabs="false">
      <a id="/:\[A1&gt;:Byte](A1)((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">/:\</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="z">z: A1</span>)</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#:+" data-isabs="false">
      <a id=":+[B&gt;:Byte, That](B)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">:+</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="elem">elem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#:\" data-isabs="false">
      <a id=":\[B](B)((Byte, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">:\</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (<span name="scala.Byte" class="extype">Byte</span>, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#==" data-isabs="false">
      <a id="==(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">==</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#==" data-isabs="false">
      <a id="==(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">==</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder):StringBuilder"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">addString</span>
        
        <span class="params">(<span name="b">b: StringBuilder</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder,String):StringBuilder"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">addString</span>
        
        <span class="params">(<span name="b">b: StringBuilder</span>, <span name="sep">sep: String</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder,String,String,String):StringBuilder"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">addString</span>
        
        <span class="params">(<span name="b">b: StringBuilder</span>, <span name="start">start: String</span>, <span name="sep">sep: String</span>, <span name="end">end: String</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#aggregate" data-isabs="false">
      <a id="aggregate[B](B)((B, Byte) ⇒ B,(B, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">aggregate</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="seqop">seqop: (B, <span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>, <span name="combop">combop: (B, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.PartialFunction#andThen" data-isabs="false">
      <a id="andThen[C]((Byte) ⇒ C):PartialFunction[Int, C]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">andThen</span>
        <span class="tparams">[<span name="C">C</span>]</span>
        <span class="params">(<span name="k">k: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ C</span>)</span><span class="result">: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Int" class="extype">Int</span>, C]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>PartialFunction → Function1</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#apply" data-isabs="false">
      <a id="apply(Int):Byte"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">apply</span>
        
        <span class="params">(<span name="idx">idx: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Byte" class="extype">Byte</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → SeqLike → GenSeqLike → Function1</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#asByteBuffer" data-isabs="false">
      <a id="asByteBuffer:ByteBuffer"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">asByteBuffer</span>
        
        <span class="result">: <span name="java.nio.ByteBuffer" class="extype">ByteBuffer</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns a read-only ByteBuffer that directly wraps this ByteString
if it is not fragmented.</p><div class="fullcomment"><div class="comment cmt"><p>Returns a read-only ByteBuffer that directly wraps this ByteString
if it is not fragmented.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></dd></dl></div>
    </li><li visbl="pub" name="scala.Any#asInstanceOf" data-isabs="false">
      <a id="asInstanceOf[T0]:T0"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">asInstanceOf</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#canEqual" data-isabs="false">
      <a id="canEqual(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">canEqual</span>
        
        <span class="params">(<span name="that">that: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → Equals</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#clone" data-isabs="false">
      <a id="clone():ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">clone</span>
        
        <span class="params">()</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#collect" data-isabs="false">
      <a id="collect[B, That](PartialFunction[Byte, B])(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">collect</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="pf">pf: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Byte" class="extype">Byte</span>, B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#collectFirst" data-isabs="false">
      <a id="collectFirst[B](PartialFunction[Byte, B]):Option[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">collectFirst</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="pf">pf: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Byte" class="extype">Byte</span>, B]</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#combinations" data-isabs="false">
      <a id="combinations(Int):Iterator[ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">combinations</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#compact" data-isabs="false">
      <a id="compact:ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">compact</span>
        
        <span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Create a new ByteString with all contents compacted into a single
byte array.</p><div class="fullcomment"><div class="comment cmt"><p>Create a new ByteString with all contents compacted into a single
byte array.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.immutable.IndexedSeq#companion" data-isabs="false">
      <a id="companion:GenericCompanion[IndexedSeq]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">companion</span>
        
        <span class="result">: <span name="scala.collection.generic.GenericCompanion" class="extype">GenericCompanion</span>[<span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeq → IndexedSeq → Seq → Seq → GenSeq → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.Function1#compose" data-isabs="false">
      <a id="compose[A]((A) ⇒ Int):(A) ⇒ Byte"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">compose</span>
        <span class="tparams">[<span name="A">A</span>]</span>
        <span class="params">(<span name="g">g: (A) ⇒ <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: (A) ⇒ <span name="scala.Byte" class="extype">Byte</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Function1</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#contains" data-isabs="false">
      <a id="contains(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">contains</span>
        
        <span class="params">(<span name="elem">elem: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#containsSlice" data-isabs="false">
      <a id="containsSlice[B](Seq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">containsSlice</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#containsSlice" data-isabs="false">
      <a id="containsSlice[B](GenSeq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">containsSlice</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#copyToArray" data-isabs="false">
      <a id="copyToArray[A&gt;:Byte](Array[A],Int,Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">copyToArray</span>
        <span class="tparams">[<span name="A">A &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[A]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>, <span name="len">len: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → IndexedSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:Byte](Array[B]):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">copyToArray</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:Byte](Array[B],Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">copyToArray</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#copyToBuffer" data-isabs="false">
      <a id="copyToBuffer(ByteBuffer):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">copyToBuffer</span>
        
        <span class="params">(<span name="buffer">buffer: <span name="java.nio.ByteBuffer" class="extype">ByteBuffer</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Copy as many bytes as possible to a ByteBuffer, starting from it's
current position.</p><div class="fullcomment"><div class="comment cmt"><p>Copy as many bytes as possible to a ByteBuffer, starting from it's
current position. This method will not overflow the buffer.
</p></div><dl class="paramcmts block"><dt class="param">buffer</dt><dd class="cmt"><p>a ByteBuffer to copy bytes to</p></dd><dt>returns</dt><dd class="cmt"><p>the number of bytes actually copied
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToBuffer" data-isabs="false">
      <a id="copyToBuffer[B&gt;:Byte](Buffer[B]):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">copyToBuffer</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="dest">dest: <span name="scala.collection.mutable.Buffer" class="extype">Buffer</span>[B]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#corresponds" data-isabs="false">
      <a id="corresponds[B](Seq[B])((Byte, B) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">corresponds</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>, B) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#corresponds" data-isabs="false">
      <a id="corresponds[B](GenSeq[B])((Byte, B) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">corresponds</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>, B) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#count" data-isabs="false">
      <a id="count((Byte) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">count</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#decodeString" data-isabs="false">
      <a id="decodeString(String):String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">decodeString</span>
        
        <span class="params">(<span name="charset">charset: String</span>)</span><span class="result">: String</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Decodes this ByteString using a charset to produce a String.</p><div class="fullcomment"><div class="comment cmt"><p>Decodes this ByteString using a charset to produce a String.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#diff" data-isabs="false">
      <a id="diff[B&gt;:Byte](Seq[B]):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">diff</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#diff" data-isabs="false">
      <a id="diff[B&gt;:Byte](GenSeq[B]):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">diff</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#distinct" data-isabs="false">
      <a id="distinct:ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">distinct</span>
        
        <span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#drop" data-isabs="false">
      <a id="drop(Int):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">drop</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#dropRight" data-isabs="false">
      <a id="dropRight(Int):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">dropRight</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#dropWhile" data-isabs="false">
      <a id="dropWhile((Byte) ⇒ Boolean):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">dropWhile</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#endsWith" data-isabs="false">
      <a id="endsWith[B](GenSeq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">endsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#endsWith" data-isabs="false">
      <a id="endsWith[B](Seq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">endsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#eq" data-isabs="false">
      <a id="eq(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">eq</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#equals" data-isabs="false">
      <a id="equals(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">equals</span>
        
        <span class="params">(<span name="that">that: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike → Equals → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#exists" data-isabs="false">
      <a id="exists((Byte) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">exists</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#filter" data-isabs="false">
      <a id="filter((Byte) ⇒ Boolean):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">filter</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#filterNot" data-isabs="false">
      <a id="filterNot((Byte) ⇒ Boolean):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">filterNot</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.AnyRef#finalize" data-isabs="false">
      <a id="finalize():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">finalize</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#find" data-isabs="false">
      <a id="find((Byte) ⇒ Boolean):Option[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">find</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#flatMap" data-isabs="false">
      <a id="flatMap[B, That]((Byte) ⇒ GenTraversableOnce[B])(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">flatMap</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Traversable#flatten" data-isabs="false">
      <a id="flatten[B]((Byte) ⇒ TraversableOnce[B]):Traversable[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">flatten</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="asTraversable">asTraversable: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[B]</span>)</span><span class="result">: <span name="scala.collection.Traversable" class="extype">Traversable</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Traversable → GenericTraversableTemplate</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#fold" data-isabs="false">
      <a id="fold[A1&gt;:Byte](A1)((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">fold</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="z">z: A1</span>)</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#foldLeft" data-isabs="false">
      <a id="foldLeft[B](B)((B, Byte) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">foldLeft</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, <span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#foldRight" data-isabs="false">
      <a id="foldRight[B](B)((Byte, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">foldRight</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (<span name="scala.Byte" class="extype">Byte</span>, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#forall" data-isabs="false">
      <a id="forall((Byte) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">forall</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#foreach" data-isabs="false">
      <a id="foreach[U]((Byte) ⇒ U):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">foreach</span>
        <span class="tparams">[<span name="U">U</span>]</span>
        <span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ U</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#genericBuilder" data-isabs="false">
      <a id="genericBuilder[B]:Builder[B, IndexedSeq[B]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">genericBuilder</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="result">: <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[B, <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[B]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#getClass" data-isabs="false">
      <a id="getClass():java.lang.Class[_]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">getClass</span>
        
        <span class="params">()</span><span class="result">: java.lang.Class[_]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#groupBy" data-isabs="false">
      <a id="groupBy[K]((Byte) ⇒ K):Map[K, ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">groupBy</span>
        <span class="tparams">[<span name="K">K</span>]</span>
        <span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ K</span>)</span><span class="result">: <span name="scala.collection.immutable.Map" class="extype">Map</span>[K, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#grouped" data-isabs="false">
      <a id="grouped(Int):Iterator[ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">grouped</span>
        
        <span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#hasDefiniteSize" data-isabs="false">
      <a id="hasDefiniteSize:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">hasDefiniteSize</span>
        
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#hashCode" data-isabs="false">
      <a id="hashCode():Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">hashCode</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#head" data-isabs="false">
      <a id="head:Byte"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">head</span>
        
        <span class="result">: <span name="scala.Byte" class="extype">Byte</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → GenIterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#headOption" data-isabs="false">
      <a id="headOption:Option[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">headOption</span>
        
        <span class="result">: <span name="scala.Option" class="extype">Option</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#indexOf" data-isabs="false">
      <a id="indexOf[B&gt;:Byte](B,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">indexOf</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="elem">elem: B</span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#indexOf" data-isabs="false">
      <a id="indexOf[B&gt;:Byte](B):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">indexOf</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="elem">elem: B</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indexOfSlice" data-isabs="false">
      <a id="indexOfSlice[B&gt;:Byte](Seq[B],Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">indexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indexOfSlice" data-isabs="false">
      <a id="indexOfSlice[B&gt;:Byte](GenSeq[B],Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">indexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indexOfSlice" data-isabs="false">
      <a id="indexOfSlice[B&gt;:Byte](Seq[B]):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">indexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indexOfSlice" data-isabs="false">
      <a id="indexOfSlice[B&gt;:Byte](GenSeq[B]):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">indexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#indexWhere" data-isabs="false">
      <a id="indexWhere((Byte) ⇒ Boolean,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">indexWhere</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#indexWhere" data-isabs="false">
      <a id="indexWhere((Byte) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">indexWhere</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#indices" data-isabs="false">
      <a id="indices:Range"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">indices</span>
        
        <span class="result">: <span name="scala.collection.immutable.Range" class="extype">Range</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#init" data-isabs="false">
      <a id="init:ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">init</span>
        
        <span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#inits" data-isabs="false">
      <a id="inits:Iterator[ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">inits</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#intersect" data-isabs="false">
      <a id="intersect[B&gt;:Byte](Seq[B]):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">intersect</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#intersect" data-isabs="false">
      <a id="intersect[B&gt;:Byte](GenSeq[B]):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">intersect</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#isDefinedAt" data-isabs="false">
      <a id="isDefinedAt(Int):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">isDefinedAt</span>
        
        <span class="params">(<span name="idx">idx: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#isEmpty" data-isabs="false">
      <a id="isEmpty:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">isEmpty</span>
        
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → GenIterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#isInstanceOf" data-isabs="false">
      <a id="isInstanceOf[T0]:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">isInstanceOf</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenTraversableLike#isTraversableAgain" data-isabs="false">
      <a id="isTraversableAgain:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">isTraversableAgain</span>
        
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>GenTraversableLike → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqLike#iterator" data-isabs="false">
      <a id="iterator:Iterator[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">iterator</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqLike → IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#last" data-isabs="false">
      <a id="last:Byte"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">last</span>
        
        <span class="result">: <span name="scala.Byte" class="extype">Byte</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#lastIndexOf" data-isabs="false">
      <a id="lastIndexOf[B&gt;:Byte](B,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastIndexOf</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="elem">elem: B</span>, <span name="end">end: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#lastIndexOf" data-isabs="false">
      <a id="lastIndexOf[B&gt;:Byte](B):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastIndexOf</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="elem">elem: B</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#lastIndexOfSlice" data-isabs="false">
      <a id="lastIndexOfSlice[B&gt;:Byte](Seq[B],Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastIndexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>, <span name="end">end: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#lastIndexOfSlice" data-isabs="false">
      <a id="lastIndexOfSlice[B&gt;:Byte](GenSeq[B],Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastIndexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>, <span name="end">end: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#lastIndexOfSlice" data-isabs="false">
      <a id="lastIndexOfSlice[B&gt;:Byte](Seq[B]):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastIndexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#lastIndexOfSlice" data-isabs="false">
      <a id="lastIndexOfSlice[B&gt;:Byte](GenSeq[B]):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastIndexOfSlice</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#lastIndexWhere" data-isabs="false">
      <a id="lastIndexWhere((Byte) ⇒ Boolean,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastIndexWhere</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>, <span name="end">end: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#lastIndexWhere" data-isabs="false">
      <a id="lastIndexWhere((Byte) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastIndexWhere</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#lastOption" data-isabs="false">
      <a id="lastOption:Option[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastOption</span>
        
        <span class="result">: <span name="scala.Option" class="extype">Option</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#length" data-isabs="false">
      <a id="length:Int"></a>
      <h4 class="signature">
      <span class="kind">val</span>
      <span class="symbol">
        <span class="name">length</span>
        
        <span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#lengthCompare" data-isabs="false">
      <a id="lengthCompare(Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lengthCompare</span>
        
        <span class="params">(<span name="len">len: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.PartialFunction#lift" data-isabs="false">
      <a id="lift:(Int) ⇒ Option[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lift</span>
        
        <span class="result">: (<span name="scala.Int" class="extype">Int</span>) ⇒ <span name="scala.Option" class="extype">Option</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>PartialFunction</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#map" data-isabs="false">
      <a id="map[B, That]((Byte) ⇒ B)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">map</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString#mapI" data-isabs="false">
      <a id="mapI((Byte) ⇒ Int):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">mapI</span>
        
        <span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">map method that will automatically cast Int back into Byte.</p><div class="fullcomment"><div class="comment cmt"><p>map method that will automatically cast Int back into Byte.
</p></div><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd><a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#max" data-isabs="false">
      <a id="max[B&gt;:Byte](Ordering[B]):Byte"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">max</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <span name="scala.Byte" class="extype">Byte</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#maxBy" data-isabs="false">
      <a id="maxBy[B]((Byte) ⇒ B)(Ordering[B]):Byte"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">maxBy</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <span name="scala.Byte" class="extype">Byte</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#min" data-isabs="false">
      <a id="min[B&gt;:Byte](Ordering[B]):Byte"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">min</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <span name="scala.Byte" class="extype">Byte</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#minBy" data-isabs="false">
      <a id="minBy[B]((Byte) ⇒ B)(Ordering[B]):Byte"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">minBy</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: <span name="scala.Byte" class="extype">Byte</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString:String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">mkString</span>
        
        <span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString(String):String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">mkString</span>
        
        <span class="params">(<span name="sep">sep: String</span>)</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString(String,String,String):String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">mkString</span>
        
        <span class="params">(<span name="start">start: String</span>, <span name="sep">sep: String</span>, <span name="end">end: String</span>)</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#ne" data-isabs="false">
      <a id="ne(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">ne</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="prt" name="akka.util.ByteString#newBuilder" data-isabs="false">
      <a id="newBuilder:ByteStringBuilder"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">newBuilder</span>
        
        <span class="result">: <a name="akka.util.ByteStringBuilder" class="extype" href="ByteStringBuilder.html">ByteStringBuilder</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd><a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a> → GenericTraversableTemplate → TraversableLike → HasNewBuilder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#nonEmpty" data-isabs="false">
      <a id="nonEmpty:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">nonEmpty</span>
        
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notify" data-isabs="false">
      <a id="notify():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">notify</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notifyAll" data-isabs="false">
      <a id="notifyAll():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">notifyAll</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.PartialFunction#orElse" data-isabs="false">
      <a id="orElse[A1&lt;:Int, B1&gt;:Byte](PartialFunction[A1, B1]):PartialFunction[A1, B1]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">orElse</span>
        <span class="tparams">[<span name="A1">A1 &lt;: <span name="scala.Int" class="extype">Int</span></span>, <span name="B1">B1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[A1, B1]</span>)</span><span class="result">: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[A1, B1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>PartialFunction</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#padTo" data-isabs="false">
      <a id="padTo[B&gt;:Byte, That](Int,B)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">padTo</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="len">len: <span name="scala.Int" class="extype">Int</span></span>, <span name="elem">elem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Parallelizable#par" data-isabs="false">
      <a id="par:ParSeq[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">par</span>
        
        <span class="result">: <span name="scala.collection.parallel.immutable.ParSeq" class="extype">ParSeq</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Parallelizable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.immutable.Seq#parCombiner" data-isabs="false">
      <a id="parCombiner:Combiner[Byte, ParSeq[Byte]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">parCombiner</span>
        
        <span class="result">: <span name="scala.collection.parallel.Combiner" class="extype">Combiner</span>[<span name="scala.Byte" class="extype">Byte</span>, <span name="scala.collection.parallel.immutable.ParSeq" class="extype">ParSeq</span>[<span name="scala.Byte" class="extype">Byte</span>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>Seq → SeqLike → Iterable → TraversableLike → Parallelizable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#partition" data-isabs="false">
      <a id="partition((Byte) ⇒ Boolean):(ByteString, ByteString)"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">partition</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: (<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>)</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#patch" data-isabs="false">
      <a id="patch[B&gt;:Byte, That](Int,Seq[B],Int)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">patch</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="patch">patch: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>, <span name="replaced">replaced: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#patch" data-isabs="false">
      <a id="patch[B&gt;:Byte, That](Int,GenSeq[B],Int)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">patch</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="patch">patch: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>, <span name="replaced">replaced: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#permutations" data-isabs="false">
      <a id="permutations:Iterator[ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">permutations</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#prefixLength" data-isabs="false">
      <a id="prefixLength((Byte) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">prefixLength</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#product" data-isabs="false">
      <a id="product[B&gt;:Byte](Numeric[B]):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">product</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="num">num: Numeric[B]</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduce" data-isabs="false">
      <a id="reduce[A1&gt;:Byte]((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reduce</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#reduceLeft" data-isabs="false">
      <a id="reduceLeft[B&gt;:Byte]((B, Byte) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reduceLeft</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="op">op: (B, <span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceLeftOption" data-isabs="false">
      <a id="reduceLeftOption[B&gt;:Byte]((B, Byte) ⇒ B):Option[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reduceLeftOption</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="op">op: (B, <span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceOption" data-isabs="false">
      <a id="reduceOption[A1&gt;:Byte]((A1, A1) ⇒ A1):Option[A1]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reduceOption</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[A1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#reduceRight" data-isabs="false">
      <a id="reduceRight[B&gt;:Byte]((Byte, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reduceRight</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="op">op: (<span name="scala.Byte" class="extype">Byte</span>, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceRightOption" data-isabs="false">
      <a id="reduceRightOption[B&gt;:Byte]((Byte, B) ⇒ B):Option[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reduceRightOption</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="op">op: (<span name="scala.Byte" class="extype">Byte</span>, B) ⇒ B</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#repr" data-isabs="false">
      <a id="repr:ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">repr</span>
        
        <span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#reverse" data-isabs="false">
      <a id="reverse:ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reverse</span>
        
        <span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#reverseIterator" data-isabs="false">
      <a id="reverseIterator:Iterator[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reverseIterator</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#reverseMap" data-isabs="false">
      <a id="reverseMap[B, That]((Byte) ⇒ B)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reverseMap</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.TraversableOnce#reversed" data-isabs="false">
      <a id="reversed:List[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">reversed</span>
        
        <span class="result">: List[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#sameElements" data-isabs="false">
      <a id="sameElements[B&gt;:Byte](GenIterable[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">sameElements</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#sameElements" data-isabs="false">
      <a id="sameElements[B&gt;:Byte](Iterable[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">sameElements</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Iterable" class="extype">Iterable</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#scan" data-isabs="false">
      <a id="scan[B&gt;:Byte, That](B)((B, B) ⇒ B)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">scan</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, B) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cbf">cbf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#scanLeft" data-isabs="false">
      <a id="scanLeft[B, That](B)((B, Byte) ⇒ B)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">scanLeft</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, <span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#scanRight" data-isabs="false">
      <a id="scanRight[B, That](B)((Byte, B) ⇒ B)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">scanRight</span>
        <span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (<span name="scala.Byte" class="extype">Byte</span>, B) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#segmentLength" data-isabs="false">
      <a id="segmentLength((Byte) ⇒ Boolean,Int):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">segmentLength</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>, <span name="from">from: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.immutable.Seq#seq" data-isabs="false">
      <a id="seq:Seq[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">seq</span>
        
        <span class="result">: <span name="scala.collection.immutable.Seq" class="extype">Seq</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Seq → Seq → GenSeq → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#size" data-isabs="false">
      <a id="size:Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">size</span>
        
        <span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#slice" data-isabs="false">
      <a id="slice(Int,Int):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">slice</span>
        
        <span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="until">until: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.util.ByteString.ByteString1" class="extype" href="">ByteString1</a> → IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#sliding" data-isabs="false">
      <a id="sliding[B&gt;:Byte](Int,Int):Iterator[ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">sliding</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>, <span name="step">step: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#sliding" data-isabs="false">
      <a id="sliding[B&gt;:Byte](Int):Iterator[ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">sliding</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#sortBy" data-isabs="false">
      <a id="sortBy[B]((Byte) ⇒ B)(Ordering[B]):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">sortBy</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span name="scala.math.Ordering" class="extype">Ordering</span>[B]</span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#sortWith" data-isabs="false">
      <a id="sortWith((Byte, Byte) ⇒ Boolean):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">sortWith</span>
        
        <span class="params">(<span name="lt">lt: (<span name="scala.Byte" class="extype">Byte</span>, <span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#sorted" data-isabs="false">
      <a id="sorted[B&gt;:Byte](Ordering[B]):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">sorted</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span name="scala.math.Ordering" class="extype">Ordering</span>[B]</span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#span" data-isabs="false">
      <a id="span((Byte) ⇒ Boolean):(ByteString, ByteString)"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">span</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: (<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>)</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#splitAt" data-isabs="false">
      <a id="splitAt(Int):(ByteString, ByteString)"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">splitAt</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: (<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>)</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#startsWith" data-isabs="false">
      <a id="startsWith[B](GenSeq[B],Int):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">startsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>, <span name="offset">offset: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#startsWith" data-isabs="false">
      <a id="startsWith[B](Seq[B],Int):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">startsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>, <span name="offset">offset: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#startsWith" data-isabs="false">
      <a id="startsWith[B](Seq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">startsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#startsWith" data-isabs="false">
      <a id="startsWith[B](GenSeq[B]):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">startsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#stringPrefix" data-isabs="false">
      <a id="stringPrefix:String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">stringPrefix</span>
        
        <span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#sum" data-isabs="false">
      <a id="sum[B&gt;:Byte](Numeric[B]):B"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">sum</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="num">num: Numeric[B]</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#synchronized" data-isabs="false">
      <a id="synchronized[T0](⇒ T0):T0"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">synchronized</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="params">(<span name="arg0">arg0: ⇒ T0</span>)</span><span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#tail" data-isabs="false">
      <a id="tail:ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">tail</span>
        
        <span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#tails" data-isabs="false">
      <a id="tails:Iterator[ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">tails</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#take" data-isabs="false">
      <a id="take(Int):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">take</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#takeRight" data-isabs="false">
      <a id="takeRight(Int):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">takeRight</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#takeWhile" data-isabs="false">
      <a id="takeWhile((Byte) ⇒ Boolean):ByteString"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">takeWhile</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.IndexedSeqLike#thisCollection" data-isabs="false">
      <a id="thisCollection:IndexedSeq[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">thisCollection</span>
        
        <span class="result">: <span name="scala.collection.IndexedSeq" class="extype">IndexedSeq</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>IndexedSeqLike → SeqLike → IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString.ByteString1#toArray" data-isabs="false">
      <a id="toArray:Array[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toArray</span>
        
        <span class="result">: <span name="scala.Array" class="extype">Array</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toArray" data-isabs="false">
      <a id="toArray[B&gt;:Byte](ClassManifest[B]):Array[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toArray</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: ClassManifest[B]</span>)</span><span class="result">: <span name="scala.Array" class="extype">Array</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqLike#toBuffer" data-isabs="false">
      <a id="toBuffer[A1&gt;:Byte]:Buffer[A1]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toBuffer</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="result">: <span name="scala.collection.mutable.Buffer" class="extype">Buffer</span>[A1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString#toByteBuffer" data-isabs="false">
      <a id="toByteBuffer:ByteBuffer"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toByteBuffer</span>
        
        <span class="result">: <span name="java.nio.ByteBuffer" class="extype">ByteBuffer</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Creates a new ByteBuffer with a copy of all bytes contained in this
ByteString.</p><div class="fullcomment"><div class="comment cmt"><p>Creates a new ByteBuffer with a copy of all bytes contained in this
ByteString.
</p></div><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd><a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></dd></dl></div>
    </li><li visbl="prt" name="scala.collection.IndexedSeqLike#toCollection" data-isabs="false">
      <a id="toCollection(ByteString):IndexedSeq[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toCollection</span>
        
        <span class="params">(<span name="repr">repr: <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></span>)</span><span class="result">: <span name="scala.collection.IndexedSeq" class="extype">IndexedSeq</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>IndexedSeqLike → SeqLike → IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.immutable.IndexedSeq#toIndexedSeq" data-isabs="false">
      <a id="toIndexedSeq[B&gt;:Byte]:IndexedSeq[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toIndexedSeq</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="result">: <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeq → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#toIterable" data-isabs="false">
      <a id="toIterable:Iterable[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toIterable</span>
        
        <span class="result">: <span name="scala.collection.Iterable" class="extype">Iterable</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#toIterator" data-isabs="false">
      <a id="toIterator:Iterator[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toIterator</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toList" data-isabs="false">
      <a id="toList:List[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toList</span>
        
        <span class="result">: List[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toMap" data-isabs="false">
      <a id="toMap[T, U](&lt;:&lt;[Byte, (T, U)]):Map[T, U]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toMap</span>
        <span class="tparams">[<span name="T">T</span>, <span name="U">U</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="ev">ev: <span name="scala.Predef.&lt;:&lt;" class="extype">&lt;:&lt;</span>[<span name="scala.Byte" class="extype">Byte</span>, (T, U)]</span>)</span><span class="result">: <span name="scala.collection.immutable.Map" class="extype">Map</span>[T, U]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.immutable.Seq#toSeq" data-isabs="false">
      <a id="toSeq:Seq[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toSeq</span>
        
        <span class="result">: <span name="scala.collection.immutable.Seq" class="extype">Seq</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Seq → SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toSet" data-isabs="false">
      <a id="toSet[B&gt;:Byte]:Set[B]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toSet</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>]</span>
        <span class="result">: <span name="scala.collection.immutable.Set" class="extype">Set</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#toStream" data-isabs="false">
      <a id="toStream:Stream[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toStream</span>
        
        <span class="result">: <span name="scala.collection.immutable.Stream" class="extype">Stream</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#toString" data-isabs="false">
      <a id="toString():String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toString</span>
        
        <span class="params">()</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → TraversableLike → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#toTraversable" data-isabs="false">
      <a id="toTraversable:Traversable[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toTraversable</span>
        
        <span class="result">: <span name="scala.collection.Traversable" class="extype">Traversable</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Traversable#transpose" data-isabs="false">
      <a id="transpose[B]((Byte) ⇒ TraversableOnce[B]):Traversable[Traversable[B]]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">transpose</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="asTraversable">asTraversable: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[B]</span>)</span><span class="result">: <span name="scala.collection.Traversable" class="extype">Traversable</span>[<span name="scala.collection.Traversable" class="extype">Traversable</span>[B]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Traversable → GenericTraversableTemplate</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#union" data-isabs="false">
      <a id="union[B&gt;:Byte, That](GenSeq[B])(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">union</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenSeqLike#union" data-isabs="false">
      <a id="union[B&gt;:Byte, That](Seq[B])(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">union</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenSeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#unzip" data-isabs="false">
      <a id="unzip[A1, A2]((Byte) ⇒ (A1, A2)):(IndexedSeq[A1], IndexedSeq[A2])"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">unzip</span>
        <span class="tparams">[<span name="A1">A1</span>, <span name="A2">A2</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="asPair">asPair: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ (A1, A2)</span>)</span><span class="result">: (<span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[A1], <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[A2])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#unzip3" data-isabs="false">
      <a id="unzip3[A1, A2, A3]((Byte) ⇒ (A1, A2, A3)):(IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">unzip3</span>
        <span class="tparams">[<span name="A1">A1</span>, <span name="A2">A2</span>, <span name="A3">A3</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="asTriple">asTriple: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ (A1, A2, A3)</span>)</span><span class="result">: (<span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[A1], <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[A2], <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[A3])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#updated" data-isabs="false">
      <a id="updated[B&gt;:Byte, That](Int,B)(CanBuildFrom[ByteString, B, That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">updated</span>
        <span class="tparams">[<span name="B">B &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="index">index: <span name="scala.Int" class="extype">Int</span></span>, <span name="elem">elem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → GenSeqLike</dd></dl></div>
    </li><li visbl="pub" name="akka.util.ByteString#utf8String" data-isabs="false">
      <a id="utf8String:String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">utf8String</span>
        
        <span class="result">: String</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Decodes this ByteString as a UTF-8 encoded String.</p><div class="fullcomment"><div class="comment cmt"><p>Decodes this ByteString as a UTF-8 encoded String.
</p></div><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd><a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#view" data-isabs="false">
      <a id="view(Int,Int):SeqView[Byte, ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">view</span>
        
        <span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="until">until: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.SeqView" class="extype">SeqView</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#view" data-isabs="false">
      <a id="view:SeqView[Byte, ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">view</span>
        
        <span class="result">: <span name="scala.collection.SeqView" class="extype">SeqView</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">wait</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long,Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">wait</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>, <span name="arg1">arg1: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">wait</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#withFilter" data-isabs="false">
      <a id="withFilter((Byte) ⇒ Boolean):FilterMonadic[Byte, ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">withFilter</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.generic.FilterMonadic" class="extype">FilterMonadic</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#zip" data-isabs="false">
      <a id="zip[A1&gt;:Byte, B, That](GenIterable[B])(CanBuildFrom[ByteString, (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">zip</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zip" data-isabs="false">
      <a id="zip[A1&gt;:Byte, B, That](Iterable[B])(CanBuildFrom[ByteString, (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">zip</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="B">B</span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Iterable" class="extype">Iterable</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zipAll" data-isabs="false">
      <a id="zipAll[B, A1&gt;:Byte, That](Iterable[B],A1,B)(CanBuildFrom[ByteString, (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">zipAll</span>
        <span class="tparams">[<span name="B">B</span>, <span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Iterable" class="extype">Iterable</span>[B]</span>, <span name="thisElem">thisElem: A1</span>, <span name="thatElem">thatElem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@bridge</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zipAll" data-isabs="false">
      <a id="zipAll[B, A1&gt;:Byte, That](GenIterable[B],A1,B)(CanBuildFrom[ByteString, (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">zipAll</span>
        <span class="tparams">[<span name="B">B</span>, <span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[B]</span>, <span name="thisElem">thisElem: A1</span>, <span name="thatElem">thatElem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IndexedSeqOptimized#zipWithIndex" data-isabs="false">
      <a id="zipWithIndex[A1&gt;:Byte, That](CanBuildFrom[ByteString, (A1, Int), That]):That"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">zipWithIndex</span>
        <span class="tparams">[<span name="A1">A1 &gt;: <span name="scala.Byte" class="extype">Byte</span></span>, <span name="That">That</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>, (A1, <span name="scala.Int" class="extype">Int</span>), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IndexedSeqOptimized → IterableLike → GenIterableLike</dd></dl></div>
    </li></ol>
            </div>

        <div class="values members" id="values">
              <h3>Deprecated Value Members</h3>
              <ol><li visbl="pub" name="scala.collection.IterableLike#elements" data-isabs="false">
      <a id="elements:Iterator[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name deprecated">elements</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>iterator' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#equalsWith" data-isabs="false">
      <a id="equalsWith[B](Seq[B])((Byte, B) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name deprecated">equalsWith</span>
        <span class="tparams">[<span name="B">B</span>]</span>
        <span class="params">(<span name="that">that: <span name="scala.collection.Seq" class="extype">Seq</span>[B]</span>)</span><span class="params">(<span name="f">f: (<span name="scala.Byte" class="extype">Byte</span>, B) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>corresponds</code> instead</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#findIndexOf" data-isabs="false">
      <a id="findIndexOf((Byte) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name deprecated">findIndexOf</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>Use indexWhere(p) instead.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#findLastIndexOf" data-isabs="false">
      <a id="findLastIndexOf((Byte) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name deprecated">findLastIndexOf</span>
        
        <span class="params">(<span name="p">p: (<span name="scala.Byte" class="extype">Byte</span>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>lastIndexWhere</code> instead</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#first" data-isabs="false">
      <a id="first:Byte"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name deprecated">first</span>
        
        <span class="result">: <span name="scala.Byte" class="extype">Byte</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>head' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#firstOption" data-isabs="false">
      <a id="firstOption:Option[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name deprecated">firstOption</span>
        
        <span class="result">: <span name="scala.Option" class="extype">Option</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>headOption' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#projection" data-isabs="false">
      <a id="projection:SeqView[Byte, ByteString]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name deprecated">projection</span>
        
        <span class="result">: <span name="scala.collection.SeqView" class="extype">SeqView</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike → IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>view' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.SeqLike#reversedElements" data-isabs="false">
      <a id="reversedElements:Iterator[Byte]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name deprecated">reversedElements</span>
        
        <span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.Byte" class="extype">Byte</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>SeqLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p>use <code>reverseIterator' instead</code></p></dd></dl></div>
    </li></ol>
            </div>

        <div name="akka.util.ByteString" class="parent">
              <h3>Inherited from <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a></h3>
            </div><div name="scala.collection.IndexedSeqOptimized" class="parent">
              <h3>Inherited from <span name="scala.collection.IndexedSeqOptimized" class="extype">IndexedSeqOptimized</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.collection.immutable.IndexedSeq" class="parent">
              <h3>Inherited from <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.IndexedSeq" class="parent">
              <h3>Inherited from <span name="scala.collection.IndexedSeq" class="extype">IndexedSeq</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.IndexedSeqLike" class="parent">
              <h3>Inherited from <span name="scala.collection.IndexedSeqLike" class="extype">IndexedSeqLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.collection.immutable.Seq" class="parent">
              <h3>Inherited from <span name="scala.collection.immutable.Seq" class="extype">Seq</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.Seq" class="parent">
              <h3>Inherited from <span name="scala.collection.Seq" class="extype">Seq</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.SeqLike" class="parent">
              <h3>Inherited from <span name="scala.collection.SeqLike" class="extype">SeqLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.collection.GenSeq" class="parent">
              <h3>Inherited from <span name="scala.collection.GenSeq" class="extype">GenSeq</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.GenSeqLike" class="parent">
              <h3>Inherited from <span name="scala.collection.GenSeqLike" class="extype">GenSeqLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.PartialFunction" class="parent">
              <h3>Inherited from <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Int" class="extype">Int</span>, <span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.Function1" class="parent">
              <h3>Inherited from (<span name="scala.Int" class="extype">Int</span>) ⇒ <span name="scala.Byte" class="extype">Byte</span></h3>
            </div><div name="scala.collection.immutable.Iterable" class="parent">
              <h3>Inherited from <span name="scala.collection.immutable.Iterable" class="extype">Iterable</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.Iterable" class="parent">
              <h3>Inherited from <span name="scala.collection.Iterable" class="extype">Iterable</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.IterableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.IterableLike" class="extype">IterableLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.Equals" class="parent">
              <h3>Inherited from <span name="scala.Equals" class="extype">Equals</span></h3>
            </div><div name="scala.collection.GenIterable" class="parent">
              <h3>Inherited from <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.GenIterableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.GenIterableLike" class="extype">GenIterableLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.collection.immutable.Traversable" class="parent">
              <h3>Inherited from <span name="scala.collection.immutable.Traversable" class="extype">Traversable</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.Immutable" class="parent">
              <h3>Inherited from <span name="scala.Immutable" class="extype">Immutable</span></h3>
            </div><div name="scala.collection.Traversable" class="parent">
              <h3>Inherited from <span name="scala.collection.Traversable" class="extype">Traversable</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.GenTraversable" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversable" class="extype">GenTraversable</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.generic.GenericTraversableTemplate" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.GenericTraversableTemplate" class="extype">GenericTraversableTemplate</span>[<span name="scala.Byte" class="extype">Byte</span>, <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>]</h3>
            </div><div name="scala.collection.TraversableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.TraversableLike" class="extype">TraversableLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.collection.GenTraversableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversableLike" class="extype">GenTraversableLike</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.collection.Parallelizable" class="parent">
              <h3>Inherited from <span name="scala.collection.Parallelizable" class="extype">Parallelizable</span>[<span name="scala.Byte" class="extype">Byte</span>, <span name="scala.collection.parallel.immutable.ParSeq" class="extype">ParSeq</span>[<span name="scala.Byte" class="extype">Byte</span>]]</h3>
            </div><div name="scala.collection.TraversableOnce" class="parent">
              <h3>Inherited from <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.GenTraversableOnce" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[<span name="scala.Byte" class="extype">Byte</span>]</h3>
            </div><div name="scala.collection.generic.FilterMonadic" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.FilterMonadic" class="extype">FilterMonadic</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.collection.generic.HasNewBuilder" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.HasNewBuilder" class="extype">HasNewBuilder</span>[<span name="scala.Byte" class="extype">Byte</span>, <a name="akka.util.ByteString" class="extype" href="ByteString.html">ByteString</a>]</h3>
            </div><div name="scala.AnyRef" class="parent">
              <h3>Inherited from AnyRef</h3>
            </div><div name="scala.Any" class="parent">
              <h3>Inherited from <span name="scala.Any" class="extype">Any</span></h3>
            </div>

      </div>

      <div id="tooltip"></div>

    </body>
      </html>